home *** CD-ROM | disk | FTP | other *** search
/ Windows Expert / Windows Expert.iso / utility / nodee1.zip / SOURCE.ZIP / NODEE.DSK (.txt) < prev    next >
Turbo C Context File  |  1991-09-01  |  21KB  |  605 lines
  1. Turbo C Context File 
  2. NODEE.RES
  3. NODEE.DEF
  4. NODEE.CPP
  5. NODCHILD.CPP
  6. NODDLGS.CPP
  7. ..\..\CLASS\CLASSWIN.CPP
  8. C:\W\A\LOCK.C
  9. C:\W\A\LOCK.DLL
  10. C:\W\A\LOCKDLL.C
  11. WMAIN.T
  12. WPROC.T
  13. A:NODEE2.CPP
  14. TO*.*
  15. A:*.*
  16. A:*.CPP
  17. NODCHILD.H
  18. *.CPP
  19. NoDWindow
  20. MainWindow
  21. wndclass
  22. lpfnWndProc
  23. lpszFile
  24. class
  25. szCleanFile
  26. NoDWindow
  27. *.DEF
  28. *.RES
  29. WMAIN2.H
  30. WMAIN2.CPP
  31. NODEE.DEF
  32. NODEE.RES
  33. *.CPP
  34. D:\PROGRAMS\CPP\NODDLGS.CPP
  35. D:\PROGRAMS\CPP\NODEE3.CPP
  36. D:\PROGRAMS\CPP\NODCHILD.CPP
  37. D:\PROGRAMS\CPP\NODDLGS.H
  38. D:\PROGRAMS\CPP\NODCHILD.H
  39. D:\PROGRAMS\CPP\NODEE3.CPP
  40. D:\PROGRAMS\CPP\NODDLGS.CPP
  41. D:\PROGRAMS\WIN\NODEE\NOD1.H
  42. D:\PROGRAMS\WIN\NODEE\NOCTRLD.DEF
  43. D:\PROGRAMS\WIN\CLASS\CLASSWIN.CPP
  44. D:\PROGRAMS\WIN\CLASS\CLASSWIN.H
  45. I        wBytesWritten=_lwrite(hFile,lpszPostscript,lstrlen(lpszPostscript));
  46.         _lclose(hFile);
  47.             MessageBox(hWnd,"File did not open",
  48.                 szClassName,MB_ICONEXCLAMATION|MB_OK);
  49.             wBytesWritten=_lwrite(hFile,lpszPostscript,lstrlen(lpszPostscript));
  50.             _lclose(hFile);
  51.             MessageBox(hWnd,"File did not open",
  52.                 szClassName,MB_ICONEXCLAMATION|MB_OK);
  53.     int PASCAL WinMain( HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpszCmdLine,
  54.                                         int nCmdShow )
  55.         Main::hInstance = hInstance;
  56.         Main::hPrevInstance = hPrevInstance;
  57.         Main::lpszCommandLine = lpszCmdLine;
  58.         Main::nCmdShow = nCmdShow;
  59.         // A Windows class should be registered with Windows before any windows
  60.         // of that type are created.
  61.         // Register here all Windows classes that will be used in the program.
  62.         // Windows classes should not be registered if an instance of
  63.         // the program is already running.
  64.         if ( ! Main::hPrevInstance ) {
  65.                 MainWindow::Register();
  66.         MainWindow MainWnd;
  67.         return Main::MessageLoop();
  68.     class MainNoDee : public Main
  69.         LPSTR DefDir;
  70.     public:
  71.         MainNoDee();
  72.     MainNoDee::MainNoDee
  73. (HANDLE a,HANDLE b,LPSTR c,int d)
  74.     HANDLE Main::hInstance = a;
  75.     HANDLE Main::hPrevInstance = 0;
  76.     LPSTR Main::lpszCommandLine = '\0';
  77.     int Main::nCmdShow = 0;
  78.     long FAR PASCAL _export WndProc
  79.         ( HWND hWnd, WORD iMessage,WORD wParam, LONG lParam );
  80.     class Main
  81.         public:
  82.         static HANDLE hInstance;
  83.         static HANDLE hPrevInstance;
  84.         static LPSTR lpszCommandLine;
  85.         static int nCmdShow;
  86.         static int MessageLoop( void );
  87.         Main(HANDLE a,HANDLE b,LPSTR c,int d);
  88.     HANDLE Main::hInstance = 0;
  89.     HANDLE Main::hPrevInstance = 0;
  90.     LPSTR Main::lpszCommandLine = '\0';
  91.     int Main::nCmdShow = 0;
  92.     Main::Main(HANDLE a,HANDLE b,LPSTR c,int d)
  93.         Main::hInstance = a;
  94.         Main::hPrevInstance = b;
  95.         Main::lpszCommandLine = c;
  96.         Main::nCmdShow = d;
  97.     int Main::MessageLoop( void )
  98.         MSG msg;
  99.         while( GetMessage( &msg, NULL, 0, 0 ) )
  100.                 TranslateMessage( &msg );
  101.                 DispatchMessage( &msg );
  102.         return msg.wParam;
  103.         ifstream ini(o.szPathName);
  104. /* Upon the first WM_CREATE message, the handle hWnd is not yet
  105. valid.  Do not use the handle until the CreateWindow call in the
  106. constructor has completed execution.  Any code which need be executed
  107. on creation can be placed in the constructor.
  108. This differs from normal C programs.  When CreateWindow sends the WM_CREATE
  109. message, the window handle is also passed to WndProc.  Thereby, the
  110. first processing of WM_CREATE will have access to the handle. */
  111.             case WM_CREATE:
  112. /* Upon the first WM_CREATE message, the handle hWnd is not yet
  113. valid.  Do not use the handle until the CreateWindow call in the
  114. constructor has completed execution.  Any code which need be executed
  115. on creation can be placed in the constructor.
  116. This differs from normal C programs.  When CreateWindow sends the WM_CREATE
  117. message, the window handle is also passed to WndProc.  Thereby, the
  118. first processing of WM_CREATE will have access to the handle. */
  119. /* All Dialog boxes derive from this class */
  120.     class Dialog
  121.     protected:
  122.         HWND hDlg;
  123.         HWND hParent;
  124.     public:
  125.         Dialog(HWND a) {hParent=a};
  126.         HWND GetHandle(void) {return hDlg;}
  127.     class AboutBox : public Dialog
  128.     public:
  129.         BOOL DlgProc(HWND hDlg,WORD message,WORD wParam,LONG lParam);
  130.         void AboutBox(HWND hParent):Dialog(hParent);
  131.     void AboutBox::AboutBox(HWND hParent):Dialog(hParent);
  132.     BOOL AboutBox::DlgProc(HWND hDlg,WORD message,WORD wParam,LONG lParam)
  133.         switch (message)
  134.             case WM_INITDIALOG:
  135.                 return TRUE;
  136.             case WM_COMMAND:
  137.                 switch (wParam)
  138.                 {
  139.                     case IDOK:
  140.                     case IDCANCEL:
  141.                         EndDialog(hDlg,0);
  142.                         return TRUE;
  143.                 }
  144.             break;
  145.         return FALSE;
  146. /* All Dialog boxes derive from this class */
  147.     class Dialog
  148.     protected:
  149.         HWND hDlg;
  150.         HWND hParent;
  151.     public:
  152.         Dialog(HWND a) {hParent=a};
  153.         HWND GetHandle(void) {return hDlg;}
  154.     class AboutBox : public Dialog
  155.     public:
  156.         BOOL DlgProc(HWND hDlg,WORD message,WORD wParam,LONG lParam);
  157.         void AboutBox(HWND hParent):Dialog(hParent);
  158.     void AboutBox::AboutBox(HWND hParent):Dialog(hParent);
  159.     BOOL AboutBox::DlgProc(HWND hDlg,WORD message,WORD wParam,LONG lParam)
  160.         switch (message)
  161.             case WM_INITDIALOG:
  162.                 return TRUE;
  163.             case WM_COMMAND:
  164.                 switch (wParam)
  165.                 {
  166.                     case IDOK:
  167.                     case IDCANCEL:
  168.                         EndDialog(hDlg,0);
  169.                         return TRUE;
  170.                 }
  171.             break;
  172.         return FALSE;
  173. (HWND hDlg,WORD message,WORD wParam,LONG lParam)
  174. pDialog->DlgProc(hDlg, iMessage, wParam, lParam );
  175. // If data pointers are near pointers
  176.     #if defined(__SMALL__) || defined(__MEDIUM__)
  177.     inline Window *GetPointer( HWND hWnd )
  178.         return (Dialog *) GetWindowWord( hWnd, 2 );
  179.     inline void SetPointer( HWND hWnd, Window *pWindow )
  180.         SetWindowWord( hWnd, 2, (WORD) pDialog );
  181.     #elif defined(__LARGE__) || defined(__COMPACT__)
  182.     inline Window *GetPointer( HWND hWnd )
  183.         return (Window *) GetWindowLong( hWnd, 4 );
  184.     inline void SetPointer( HWND hWnd, Window *pWindow )
  185.         SetWindowLong( hWnd, 4, (LONG) pDialog );
  186.     #else
  187.         #error Choose another memory model!
  188.     #endif
  189. /* All Dialog boxes derive from this class */
  190.     class Dialog
  191. DlgProc(hDlg, iMessage, wParam, lParam )
  192.                         DialogBox
  193.                             (Main::hInstance,"AboutBox",hWnd,lpfnDlgProc);
  194.                         AboutBox A(hWnd,lpfnDlgProc);
  195. FARPROC lpfnDlgProc
  196.         hParent=0;
  197. // If data pointers are near pointers
  198.     #if defined(__SMALL__) || defined(__MEDIUM__)
  199.     inline void SetDlgPointer( HWND hWnd, Dialog *pDialog )
  200.         SetWindowWord( hWnd, 2, (WORD) pDialog );
  201.     #elif defined(__LARGE__) || defined(__COMPACT__)
  202.     inline void SetDlgPointer( HWND hWnd, Dialog *pDialog )
  203.         SetWindowLong( hWnd, 4, (LONG) pDialog );
  204.     #else
  205.         #error Choose another memory model!
  206.     #endif
  207. /* All dialog boxes are included from a separate file for convienence.
  208. An independent symbol table is used. */
  209. //    #include "dlg1.h"
  210.     #include "dlg1.cpp"
  211. // the Main class
  212.     #include "wmain2.h"
  213. // the Main class
  214.     #include "wmain2.h"
  215. /*---------------------------------------------------
  216.  All dialog boxes are included from a separate file for convienence.
  217. An independent symbol table is used. */
  218. //    #include "dlg1.h"
  219.     #include "dlg1.cpp"
  220.     long FAR PASCAL _export WndProc
  221.         ( HWND hWnd, WORD iMessage,WORD wParam, LONG lParam );
  222.     class AboutBox : public Dialog
  223.     public:
  224.         BOOL DlgProc(HWND hDlg,WORD message,WORD wParam,LONG lParam);
  225.         AboutBox(HWND hParent,FARPROC lprnDlgProc);
  226.     AboutBox::AboutBox(HWND hParent,FARPROC lpfnDlgProc):Dialog(hParent)
  227.         DialogBox
  228.             (Main::hInstance,"AboutBox",hParent,lpfnDlgProc);
  229.     BOOL AboutBox::DlgProc(HWND hDlg,WORD message,WORD wParam,LONG lParam)
  230.         switch (message)
  231.             case WM_INITDIALOG:
  232.                 return TRUE;
  233.             case WM_COMMAND:
  234.                 switch (wParam)
  235.                 {
  236.                     case IDOK:
  237.                     case IDCANCEL:
  238.                         EndDialog(hDlg,0);
  239.                         return TRUE;
  240.                 }
  241.             break;
  242.         return FALSE;
  243. MainNoD::szDefDir,MB_ICONEXCLAMATION|MB_OK);
  244.                 io.close();
  245.                 MessageBox(hWnd,"File contains ^D",
  246.                     MainNoD::szDefDir,MB_ICONEXCLAMATION|MB_OK);
  247.             MessageBox(hWnd,"File cleaned",
  248.                 MainNoD::szDefDir,MB_ICONEXCLAMATION|MB_OK);
  249.             return 1;
  250. inline HANDLE WinBase::hWnd()
  251.         return hWindow;
  252. inline ModalDialog::ModalDialog( HWND hOwner ) : result( 0 )
  253.         assert( curDlg == 0 );
  254.         curDlg = this;
  255.         hWindow = hOwner;
  256. inline ModalDialog::~ModalDialog()
  257.         assert( curDlg != 0 );
  258.         curDlg = 0;
  259. inline void Window::insert()
  260.         nextWin = winList;
  261.         winList = this;
  262. inline HANDLE WinBase::hWnd()
  263.         return hWindow;
  264. inline void Window::insert()
  265.         nextWin = winList;
  266.         winList = this;
  267. //---------------------------------------------------------------------
  268. //  class SaveDir is only used locally, although it makes a handy
  269. //  addition to a toolbox.  When created it saves the current drive
  270. //  and directory, and when destroyed it restores the drive and path
  271. //  to the saved drive and directory.
  272. //---------------------------------------------------------------------
  273. class SaveDir
  274. public:
  275.         SaveDir();
  276.         ~SaveDir();
  277. private:
  278.     int drive;
  279.         char path[MAXPATH];
  280. SaveDir::SaveDir()
  281.     drive = getdisk();
  282.         path[0] = '\\';
  283.     getcurdir( 0, path+1 );
  284. SaveDir::~SaveDir()
  285.         setdisk( drive );
  286.     chdir( path );
  287. /* Member functions to be defined later
  288.  Print a message in the client rectangle. */
  289.         long WndProc( WORD iMessage, WORD wParam, LONG lParam );
  290.         void Paint( void );
  291.         int Strip(LPSTR lpszFile);
  292.         void Paint( void );
  293.         int Strip(LPSTR lpszFile);
  294.             hMenu=LoadMenu(Main::hInstance,"MENU");
  295.             SetMenu(hWnd,hMenu);
  296.                     case IDM_OPT1A:
  297.                         Strip(Main::lpszCommandLine);
  298.                         return 0;
  299.                     case IDM_OPT1B:
  300.                         if (GetMenuState(hMenu,IDM_OPT1B,MF_BYCOMMAND)&&MF_CHECKED)
  301.                             CheckMenuItem(hMenu,IDM_OPT1B,MF_UNCHECKED);
  302.                         else
  303.                             CheckMenuItem(hMenu,IDM_OPT1B,MF_CHECKED);
  304.                         return 0;
  305.                     case IDM_H1A:
  306.                         WhoWroteBox x(hwnd);
  307.                         x.run();
  308.                         return 0;
  309.                     case IDM_H1B:
  310.                         AboutBox p(hWnd);
  311.                         p.run();
  312.                         return 0;
  313.                     default:
  314.                         MessageBeep(0);
  315. /* Define the members of NoDWindow */
  316.     char NoDWindow::szClassName[] = "No ^D !";
  317. /*---------------------------------------------------------------------
  318.     class AboutBox
  319.             draws and manages the About dialog.
  320.     class AboutBox : public ModalDialog
  321.     public:
  322.         AboutBox( HWND );
  323.     private:
  324.         virtual LPSTR getDialogName();
  325.         virtual BOOL dispatch( HWND, WORD, WORD, LONG );
  326.     LPSTR AboutBox::getDialogName()
  327.         return "AboutBox";
  328.     BOOL AboutBox::dispatch( HWND hDlg, WORD msg, WORD wParam, LONG lParam )
  329.         switch( msg )
  330.             case WM_INITDIALOG:
  331.                         return TRUE;        // no initialization.
  332.             case WM_COMMAND:
  333.                 if( wParam == IDOK || wParam == IDCANCEL )
  334.                 {
  335.                     EndDialog( hDlg, TRUE );  // selecting OK or Cancel
  336.                     return TRUE;              // terminates the dialog
  337.                 }
  338.             default:
  339.             return ModalDialog::dispatch( hDlg, msg, wParam, lParam );
  340. inline TodoWindow::TodoWindow() : fileName( 0 )
  341. inline TodoWindow::~TodoWindow()
  342.     inline AboutBox::AboutBox(HWND hOwner) : ModalDialog(hOwner)
  343.     inline AboutBox::AboutBox(HWND hOwner) : ModalDialog(hOwner)
  344.     inline WhoWroteBox::WhoWroteBox(HWND hOwner) : ModalDialog(hOwner)
  345. HANDLE WinBase::hInst = _hInstance;
  346. HANDLE WinBase::hPrevInst = _hPrev;
  347. LPSTR WinBase::cmd = _pszCmdline;
  348. int WinBase::show = _cmdShow;
  349.             WhoWroteBox x(hWnd());
  350.             x.run();
  351.             hdc=GetDC(hWnd());
  352.             SelectObject(hdc,GetStockObject(SYSTEM_FONT));
  353.             GetTextMetrics(hdc,&tm);
  354.             cxChar=tm.tmAveCharWidth;
  355.             cyChar=tm.tmHeight+tm.tmExternalLeading;
  356.             cxCaps=(tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar/2;
  357.             ReleaseDC(hWnd(),hdc);
  358.     BOOL NoDWindow::processMenuCommand(WORD wParam, long lParam)
  359.         switch(wParam)
  360.         case IDM_OPT1A:
  361.             strip(WinBase::cmd);
  362.             return TRUE;
  363.         case IDM_OPT1B:
  364.             if (GetMenuState(hMenu,IDM_OPT1B,MF_BYCOMMAND)&&MF_CHECKED)
  365.                 CheckMenuItem(hMenu,IDM_OPT1B,MF_UNCHECKED);
  366.             else
  367.                 CheckMenuItem(hMenu,IDM_OPT1B,MF_CHECKED);
  368.             return TRUE;
  369.         case IDM_H1A:
  370.             helpWroteBox();
  371.             return TRUE;
  372.         case IDM_H1B:
  373.             helpAboutBox();
  374.             return TRUE;
  375.         default:
  376.             MessageBeep(0);
  377.             return FALSE;
  378.             strip(WinBase::cmd);
  379.         void paint( void );
  380.         int strip(LPSTR lpszFile);
  381.         HWND hwndButton;
  382.         HWND hParent;
  383.         char *text="GO !"
  384.     inline HANDLE GoButton::getHandle()
  385.         return hwndButton;
  386.         HDC hdc;
  387.         TEXTMETRIC tm;
  388.         int cxChar,cyChar;
  389.         hParent=hA;
  390.         hdc=GetDC(hParent);
  391.         SelectObject(hdc,GetStockObject(SYSTEM_FIXED_FONT));
  392.         GetTextMetrics(hdc,&tm);
  393.         cxChar=tm.tmAveCharWidth;
  394.         cyChar=tm.tmHeight+tm.tmExternalLeading;
  395.         ReleaseDC(hParent,hdc);
  396.         hwndChild=CreateWindow
  397.             ("button",text,WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON,
  398.             40*cxChar,10*cyChar,
  399.             (len(text)+2)*cxChar,7*cyChar/4,
  400.             hParent,MYCW_GOBUTTON,WinBase::hInst,NULL);
  401.         HWND getHandle(void);
  402.         HWND hwndChild;
  403.         HWND hParent;
  404.     inline HANDLE GoButton::getHandle()
  405.         return hwndChild;
  406.                     int cx,cy;
  407.                     cx=GetSystemMetrics(SM_CXSCREEN);
  408.                     cy=GetSystemMetrics(SM_CYSCREEN);
  409. WS_DLGFRAME
  410.         HDC hdc;
  411.         TEXTMETRIC tm;
  412.         int cxChar,cyChar;
  413.         text="nothing yet";
  414.         hParent=hA;
  415.         hdc=GetDC(hParent);
  416.         SelectObject(hdc,GetStockObject(SYSTEM_FIXED_FONT));
  417.         GetTextMetrics(hdc,&tm);
  418.         cxChar=tm.tmAveCharWidth;
  419.         cyChar=tm.tmHeight+tm.tmExternalLeading;
  420.         ReleaseDC(hParent,hdc);
  421.         hwndChild=CreateWindow
  422.             ("static",text,WS_CHILDWINDOW|WS_VISIBLE|SS_LEFT,
  423.             10*cxChar,2*cyChar,
  424.             (30+2)*cxChar,7*cyChar/4,
  425.             hParent,MYCW_FIRSTLINE,WinBase::hInst,NULL);
  426.     void FirstLine::create(HWND hA)
  427.     void FirstLine::set(LPSTR a)
  428.         SetWindowText(hwndChild,a);
  429.                 fl.set("Postscript");
  430.                 fl.set(szBuffer);
  431.                 fl.set(szBuffer);
  432.             getcwd(szFileName,MAXPATH);
  433.     BOOL FileList::fileClick(void)
  434.         int index;
  435.         char szBuffer[MAXPATH];
  436.         OFSTRUCT ofs;
  437.         if (LB_ERR ==    (index= (WORD) send(LB_GETCURSEL,0,0L)) )
  438.                 return FALSE;
  439.         send(LB_GETTEXT,index,(LONG) (char far *) szBuffer);
  440.         if (-1 != OpenFile(szBuffer,&ofs,OF_EXIST|OF_READ))
  441.             bValidFile=TRUE;
  442.             getcwd(szFileName,MAXPATH);
  443.             if (szBuffer[strlen(szFileName)-1] != '\\')
  444.                 strcat(szFileName,"\\");
  445.             strcat(szFileName,szBuffer);
  446.         else
  447.             bValidFile=FALSE;
  448.             szBuffer[strlen(szBuffer)-1] = '\0';
  449.             chdir(szBuffer+1);
  450.             getcwd(szBuffer,MAXPATH);
  451.             SetWindowText(hDirField,szBuffer);
  452.             send(LB_RESETCONTENT,0,0L);
  453.             send(LB_DIR,0x37,(LONG)(LPSTR) "*.*");
  454.         return TRUE;
  455.         SendMessage(hDirList,LB_DIR,0xC010,(LONG)(LPSTR) "*.*");
  456.             if (bOneClick)
  457.                 CheckMenuItem(hMenu,IDM_OPT1B,MF_CHECKED);
  458.             else
  459.                 CheckMenuItem(hMenu,IDM_OPT1B,MF_UNCHECKED);
  460.             return TRUE;
  461.             send(LB_RESETCONTENT,0,0L);
  462.             send(LB_DIR,0x0,(LONG)(LPSTR) "*.*");
  463.                             dbox.unset();
  464.                             EnableWindow(gb.getHandle(),FALSE);
  465.                             SetFocus(hWnd());
  466.                         if (test(lpszCleanFile))
  467.                         {
  468.                             dbox.set();
  469.                             EnableWindow(gb.getHandle(),TRUE);
  470.                             SetFocus(gb.getHandle());
  471.                         }
  472.                         else
  473.                         {
  474.                             dbox.unset();
  475.                             EnableWindow(gb.getHandle(),FALSE);
  476.                             SetFocus(hWnd());
  477.                         }
  478.         bValidFile=FALSE;
  479.         szBuffer[strlen(szBuffer)-1] = '\0';
  480.         chdir(szBuffer+1);
  481.         getcwd(szBuffer,MAXPATH);
  482.         SetWindowText(hDirField,szBuffer);
  483.         bValidFile=FALSE;
  484.                         if (test(lpszCleanFile))
  485.                         {
  486.                             dbox.set();
  487.                             EnableWindow(gb.getHandle(),TRUE);
  488.                             SetFocus(gb.getHandle());
  489.                         }
  490.                         else
  491.                         {
  492.                             dbox.unset();
  493.                             EnableWindow(gb.getHandle(),FALSE);
  494.                             SetFocus(hWnd());
  495.                         }
  496.                         {
  497.                             dbox.set();
  498.                             EnableWindow(gb.getHandle(),TRUE);
  499.                             SetFocus(gb.getHandle());
  500.                         }
  501.                         {
  502.                             dbox.unset();
  503.                             EnableWindow(gb.getHandle(),FALSE);
  504.                             SetFocus(hWnd());
  505.                         }
  506.             return TRUE;
  507.             dbox.unset();
  508.             EnableWindow(gb.getHandle(),FALSE);
  509.             SetFocus(hWnd());
  510.             bOneClick=!bOneClick;
  511.             if (bOneClick)
  512.                 CheckMenuItem(hMenu,IDM_OPT1B,MF_CHECKED);
  513.             else
  514.                 CheckMenuItem(hMenu,IDM_OPT1B,MF_UNCHECKED);
  515.             if (bOneClick)
  516.                 CheckMenuItem(hMenu,IDM_OPT1B,MF_CHECKED);
  517.             else
  518.                 CheckMenuItem(hMenu,IDM_OPT1B,MF_UNCHECKED);
  519.             WritePrivateProfileString
  520.                 ("NoDee","OneClick",(int) OneClick,"nodee.ini");
  521.         if(bInstantStrip)
  522.             WritePrivateProfileString
  523.                 ("NoDee","OneClick","True","nodee.ini");
  524.         else
  525.             WritePrivateProfileString
  526.                 ("NoDee","OneClick","False","nodee.ini");
  527.             if (GetPrivateProfileInt
  528.                 ("NoDee","OneClick",1,"nodee.ini") == 0)
  529.                 bOneClick=FALSE;
  530.             else
  531.                 bOneClick=TRUE;
  532. SetClassWord(hwnd(),GCW_HCURSOR,
  533.                 SetClassWord(hwnd(),GCW_HCURSOR,LoadCursor(hInst,"NODEE"));
  534.                 SetClassWord(hwnd(),GCW_HCURSOR,LoadCursor(NULL,IDC_ARROW));
  535. (int) (szBuffer[2]) -  'a'
  536.         send(LB_RESETCONTENT,0,0L);
  537.         send(LB_DIR,0x0,(LONG)(LPSTR) "*.*");
  538.         SendMessage(hDirList,LB_RESETCONTENT,0,0L);
  539.         SendMessage(hDirList,LB_DIR,0xc010,(LONG)(LPSTR) "*.*");
  540.             CheckMenuItem(hMenu,IDM_OPT1C,bUseFileMask ? MF_CHECKED:MF_UNCHECKED);
  541.             childFileList.mask(bUseFileMask ? "*.ps" : "*.*" );
  542.             CheckMenuItem(hMenu,IDM_OPT1A,bInstantStrip ? MF_CHECKED:MF_UNCHECKED);
  543.             childFileList.mask(bUseFileMask ? "*.ps" : "*.*" );
  544.             CheckMenuItem(hMenu,IDM_OPT1C,bUseFileMask ? MF_CHECKED:MF_UNCHECKED);
  545.     char NoDWindow::szClassName[] = "No ^D !";
  546.     #pragma arsused
  547.         SetWindowText(hDirField,szDirName);
  548.         SetWindowText(hDirField,szDirName);
  549.             SetClassWord
  550.                 (childFileList.FileList::getHandle(), GCW_HCURSOR,    bInstantStrip ?
  551.                 LoadCursor(hInst,"NODEE"):LoadCursor(NULL,IDC_ARROW) );
  552.                 SetClassWord
  553.                 (childFileList.FileList::getHandle(), GCW_HCURSOR,
  554.                  LoadCursor(NULL,IDC_ARROW) );
  555.             GetPrivateProfileString
  556.                 ("NoDee","Mask",szMask,MAXPATH,"nodee.ini")
  557.         if (GetPrivateProfileString
  558.             ("NoDee","DefDir","",szDefDir,MAXPATH,"nodee.ini") != 0 )
  559.             WinHelp(hWindow,HELPFILE,HELP_INDEX,NULL);
  560.         hPoint=LoadBitmap(WinBase::hInst,"D1");
  561.         hDC=GetDC(hWindow);
  562.         hdcMem=CreateCompatibleDC(hDC);
  563.         SelectObject(hdcMem,hPoint);
  564.         SetMapMode(hdcMem,GetMapMode(hDC));
  565.         GetObject(hPoint,sizeof(BITMAP),(LPSTR) &bm);
  566.         ptSize.x=bm.bmWidth;
  567.         ptSize.y=bm.bmHeight;
  568.         DPtoLP(hdc,&ptSize,1);
  569.         ptOrg.x=cxClient-ptSize.x
  570.         ptOrg.y=0;
  571.         DPtoLP(hdcMem,&ptOrg,1);
  572.         BitBlt(hdc,xStart,yStart,ptSize.x,ptSize.y,
  573.                         hdcMem,ptOrg.x,ptOrg.y,SRCCOPY);
  574.         Delete (hdcMem);
  575.         ReleaseDC(hWindow,hDC);
  576. cxClient-ptSize.x
  577. cxClient-ptSize.x
  578.         hPoint=LoadBitmap(WinBase::hInst,"D5");
  579.         hPoint=LoadBitmap(WinBase::hInst,"D5");
  580.         SelectObject(hdcMem,hPoint);
  581.         SetMapMode(hdcMem,GetMapMode(hDC));
  582.         GetObject(hPoint,sizeof(BITMAP),(LPSTR) &bm);
  583.         ptSize.x=bm.bmWidth;
  584.         ptSize.y=bm.bmHeight;
  585.         DPtoLP(hDC,&ptSize,1);
  586.         ptOrg.x=0;
  587.         ptOrg.y=0;
  588.         DPtoLP(hdcMem,&ptOrg,1);
  589.         BitBlt(hDC,cxClient-ptSize.x,0,ptSize.x,ptSize.y,
  590.                         hdcMem,ptOrg.x,ptOrg.y,SRCCOPY);
  591.         hPoint=LoadBitmap(WinBase::hInst,"D4");
  592.         SelectObject(hdcMem,hPoint);
  593.         SetMapMode(hdcMem,GetMapMode(hDC));
  594.         GetObject(hPoint,sizeof(BITMAP),(LPSTR) &bm);
  595.         ptSize.x=bm.bmWidth;
  596.         ptSize.y=bm.bmHeight;
  597.         DPtoLP(hDC,&ptSize,1);
  598.         ptOrg.x=0;
  599.         ptOrg.y=0;
  600.         DPtoLP(hdcMem,&ptOrg,1);
  601.         BitBlt(hDC,cxClient-ptSize.x,0,ptSize.x,ptSize.y,
  602.                         hdcMem,ptOrg.x,ptOrg.y,SRCCOPY);
  603.             Copyright (c) 1991 by Borland International
  604.             All Rights Reserved.
  605.